There are asynchronously refreshing, networked applications where data is periodically refreshed across a network for display on a computer that executes such an application. An application may be considered to asynchronously refresh when the time for the refresh is not pre-arranged between the application and a server from which the application refreshes data. Where the networked application has a multi-threaded user interface (a thread being a line of execution within an application or process that maintains state information as to its execution and shares memory and other resources with other threads of the application), there may be one thread of the application that refreshes data, and another thread of the application that receives user input locally. The data-refresh thread and the user-input thread may then share a mutex or semaphore so that they do not conflict—so that data integrity is not compromised where a user-initiated event concurrently modifies the data model during the mutating part of the refresh action.
Where the asynchronously refreshing, networked application has only a single thread of execution, there are also techniques for refreshing data across a network. One technique involves synchronously blocking the entire user interface of the single-threaded application while updating the application's data model (a data model is a structured arrangement of data for storage and/or presentation). However, there are many problems with refreshing the data model of a single-threaded, rich networked application, some of which are well known.